namespace type {

    // 类型判断
    // 用于确定变量或表达式的类型
    // 1、使用tyoeof 获取原始数据的类型或对象的类型
    function printType(value: any): void {
        if (typeof value === 'string') {
            console.log('this is a string');

        } else if (typeof value === 'number') {
            console.log('this is a number');

        } else if (typeof value === 'boolean') {
            console.log('this is a boolean');

        } else {
            console.log('unknown type');

        }
    }
    printType('hello'); // this is a string
    printType(42); // this is a number


    // 2、使用 instanceof 
    // 检查对象是否是某个构造函数的实例，适用于类和接口的判断
    class Dog {
        bark() {
            console.log('woof!');
        }
    }

    class Cat {
        meow() {
            console.log('meow!');
        }
    }

    function checkAnimal(animal: Dog | Cat): void {
        if (animal instanceof Dog) {
            animal.bark()
        } else if (animal instanceof Cat) {
            animal.meow()
        }
    }
    const dog = new Dog()
    checkAnimal(dog) // woof!
    const cat = new Cat()
    checkAnimal(cat) // meow!


    // 3、使用自定义类型维护
    // 通过返回 values is Type 的形式，明确告知编译器某个值的类型
    interface Fish {
        swim(): void;
    }

    interface Bird {
        fly(): void
    }

    function isFish(pet: Fish | Bird): pet is Fish {
        return (pet as Fish).swim !== undefined
    }

    function checkPet(pet: Fish | Bird): void {
        if (isFish(pet)) {
            pet.swim()
        } else {
            pet.fly()
        }
    }


    // 4、使用in 操作符
    // 用于判断某个属性是否存在于对象中，常用于联合类型判断
    interface Cat {
        drive(): void
    }

    interface Boat {
        sail(): void
    }

    function move(vehicle: Cat | Boat): void {
        if ('drive' in vehicle) {
            vehicle.drive()
        } else {
            vehicle.sail()
        }
    }

    // 5、使用 严格相等 === 进行特定值判断
    // 对于特定的枚举类型或者字面量联合类型，可以使用严格相等（===）进行判断
    type Direction = 'up' | 'down' | 'left' | 'right'
    function moveDirection(direction: Direction): void {
        if (direction === "up") {
            console.log('Moving up');

        } else if (direction === "down") {
            console.log('Moving down');

        } else if (direction === "left") {
            console.log('Moving left');

        } else if (direction === "right") {
            console.log('Moving right');

        } else {
            console.log('error direction');

        }
    }

    // 6、使用 switch 语句
    // 用于对联合类型或枚举类型的所有可能值进行全面处理
    enum Color {
        Red,
        Green,
        Blue
    }

    function chooseColor(color: Color): void {
        switch (color) {
            case Color.Red:
                console.log("Red color chosen.");
                break;
            case Color.Green:
                console.log("Green color chosen.");
                break;
            case Color.Blue:
                console.log("Blue color chosen.");
                break;
            default:
                console.log("Unknown color.");
                break;
        }
    }

    // 总结

    // 在 TypeScript 中，类型判断有多种方法，每种方法适用于不同的场景。
    // typeof 和 instanceof 是最常用的原始类型和对象类型检查工具，
    // 而自定义类型保护、in 操作符、以及 switch 语句则
    // 可以在更复杂的类型判断中 提供强大的类型安全支持。









}